/**
 * 预览服务
 * 处理组件的预览相关逻辑
 */

import componentManager from './ComponentManagerService';

export class PreviewService {
  /**
   * 处理单个组件预览
   * @param {Object} component 组件数据
   * @returns {Promise<Object>} 处理后的组件数据
   */
  async prepareComponentForPreview(component) {
    try {
      // 动态加载组件的预览处理模块
      const previewHandler = await componentManager.loadPreviewHandler(component.type);
      
      if (previewHandler && previewHandler.preparePreviewData) {
        // 使用组件特定处理
        return previewHandler.preparePreviewData(component);
      }
      
      // 默认处理
      return this.defaultPreviewProcessor(component);
    } catch (error) {
      console.error(`[PreviewService] 预览处理错误 (${component.type}):`, error);
      return this.defaultPreviewProcessor(component);
    }
  }
  
  /**
   * 默认预览处理
   * @param {Object} component 组件数据
   * @returns {Object} 处理后的组件数据
   */
  defaultPreviewProcessor(component) {
    return {
      ...component,
      isPreviewMode: true,
      // 适配通用属性，确保能在预览模式运行
      props: {
        ...component.props,
        isPreviewMode: true,
        isExportMode: false
      }
    };
  }
  
  /**
   * 处理组件树进行预览
   * @param {Array} components 组件树
   * @returns {Promise<Array>} 处理后的组件树
   */
  async prepareComponentTreeForPreview(components) {
    if (!Array.isArray(components)) {
      return [];
    }
    
    // 递归处理组件树
    const result = [];
    
    for (const component of components) {
      // 处理当前组件
      const processedComponent = await this.prepareComponentForPreview(component);
      
      // 处理子组件
      if (processedComponent.children && processedComponent.children.length > 0) {
        processedComponent.children = await this.prepareComponentTreeForPreview(processedComponent.children);
      }
      
      result.push(processedComponent);
    }
    
    return result;
  }
  
  /**
   * 获取组件的预览选项
   * @param {string} componentType 组件类型
   * @returns {Promise<Object>} 预览选项
   */
  async getComponentPreviewOptions(componentType) {
    try {
      const previewHandler = await componentManager.loadPreviewHandler(componentType);
      
      if (previewHandler && previewHandler.renderOptions) {
        return previewHandler.renderOptions;
      }
    } catch (error) {
      console.warn(`[PreviewService] 无法获取组件预览选项: ${componentType}`, error);
    }
    
    // 默认预览选项
    return {
      useWrapper: true,
      interactive: true,
      renderChildren: true
    };
  }
  
  /**
   * 处理预览模式下的组件交互
   * @param {Object} component 组件数据
   * @param {Object} event 事件数据
   * @param {Object} context 上下文
   * @returns {Promise<boolean>} 是否允许事件冒泡
   */
  async handlePreviewInteraction(component, event, context = {}) {
    if (!component || !component.type) {
      return true;
    }
    
    try {
      const previewHandler = await componentManager.loadPreviewHandler(component.type);
      
      if (previewHandler && previewHandler.handlePreviewInteraction) {
        return previewHandler.handlePreviewInteraction(component, context);
      }
    } catch (error) {
      console.error(`[PreviewService] 预览交互处理错误: ${component.type}`, error);
    }
    
    // 默认允许事件冒泡
    return true;
  }
}

// 创建单例实例
const previewService = new PreviewService();

export default previewService; 